home *** CD-ROM | disk | FTP | other *** search
/ Fritz: All Fritz / All Fritz.zip / All Fritz / FILES / WORDMISC / MICROSPL.LZH / DMERGE.C < prev    next >
C/C++ Source or Header  |  1987-07-22  |  6KB  |  303 lines
  1. /*    DMERGE:    Dictionary Merge Utility for MicroSPELL 1.0
  2.         Spell Checker and Corrector
  3.  
  4.         (C)opyright May 1987 by Daniel Lawrence
  5.         All Rights Reserved
  6.  
  7.     Revision History:
  8.  
  9. */
  10.  
  11. #define    maindef    1
  12.  
  13. #include    <stdio.h>
  14. #include    "dopt.h"
  15. #include    "dstruct.h"
  16. #include    "ddef.h"
  17.  
  18. /*    GLOBALS for DMERGE    */
  19.  
  20. char dname[NSTRING];        /* main output dictionary text file */
  21. int upflag;            /* processing upper case flag */
  22.  
  23. main(argc, argv)
  24.  
  25. int argc;    /* command line argument count */
  26. char **argv;    /*              argument vector */
  27.  
  28. {
  29.     WORD *tword;
  30.  
  31.     /* check to see if they need help.... */
  32.     if (argc < 3) {
  33.         usage();
  34.         exit(EXBADOPT);
  35.     }
  36.  
  37.     /* announce us */
  38.     printf("DMERGE %s    Dictionary merge Utility\n", VERSION);
  39.  
  40.     /* grab the output dictionary name */
  41.     --argc;
  42.     argv++;
  43.     strcpy(dname, argv[0]);
  44.  
  45.     /* and read in the user word lists */
  46.     while (--argc) {
  47.         argv++;        /* skip to next argument */
  48.         uread(argv[0]);    /* and read the dictionary in */
  49.     }
  50.  
  51.     /* prepare to merge */
  52.     comsort();
  53.     if (numfiltr)
  54.         printf("%u User words loaded\n", numfiltr);
  55.     else {
  56.         printf("%%No user words loaded\n");
  57.         exit(EXBADOPT);
  58.     }
  59.  
  60.     if (mopen() == FALSE)
  61.         exit(EXMDICT);
  62.  
  63.     /* open the output dictionary file */
  64.     if ((outfile = fopen(dname, "w")) == NULL) {
  65.         printf("%%Can not open output dictionary file\n");
  66.         exit(EXTEMP);
  67.     }
  68.  
  69.     /* and do the merge */
  70.     printf("[Merging....]");
  71.     merge();
  72.     printf("\n%u words merged ... new dictionary is %u words long\n",
  73.             numfiltr, totwords);
  74.  
  75.     mclose();
  76.     fclose(outfile);
  77.     exit(EXGOOD);
  78. }
  79.  
  80. usage()        /* print the command line usage */
  81.  
  82. {
  83.     printf("DMERGE:    Dictionary Merge Utility\n");
  84.     printf("    for MicroSPELL %s\n",VERSION);
  85.     puts("\nUsage\n");
  86.     puts("    dmerge <output dictionary> <user file> {<user file>..}\n");
  87. }
  88.  
  89. int merge()        /* do a merge run against the main dictionary    */
  90.  
  91. {
  92.     register char **curword;/* ptr to current word */
  93.     register int cmp;    /* result of comparison */
  94.     char mword[NSTRING];    /* current dictionary word */
  95.  
  96.     /* make sure the common word list ends with hivalue */
  97.     strcpy(cword[numfiltr], hivalue);
  98.     upflag = TRUE;
  99.  
  100.     /* start with the first word in each list */
  101.     strcpy(mword, nxtmword());
  102.     curword = &cword[0];
  103.  
  104.     while (strcmp(*curword, hivalue) < 0 || strcmp(mword, hivalue) < 0) {
  105.  
  106.         /* compare a dictionary word and a user word */
  107.         cmp = strcmp(*curword, mword);
  108.  
  109.         /* and write out the appropriate one */
  110.         if (cmp > 0) {
  111.             outword(mword);
  112.             strcpy(mword, nxtmword());
  113.         } else if (cmp < 0) {
  114.             outword(*curword);
  115.             curword++;
  116.         } else {
  117.             outword(*curword);
  118.             strcpy(mword, nxtmword());
  119.             curword++;
  120.         }
  121.     }
  122. }
  123.  
  124. outword(word)    /* output a word to the new main dictionary text file */
  125.  
  126. char *word;    /* word to write to dictionary */
  127.  
  128. {
  129.     /* if this is the seperator character, toggle uppercase flag off */
  130.     if (*word == SEPCHAR)
  131.         upflag = FALSE;
  132.  
  133.     /* If we switch from upper to lower case with no seperator,
  134.        insert one */
  135.     if (upflag)
  136.         if (islower(*word)) {
  137.             fprintf(outfile, "%c\n", SEPCHAR);
  138.             upflag = FALSE;
  139.         }
  140.  
  141.     /* and finally, dump the word out */
  142.     fprintf(outfile, "%s\n", word);
  143.     totwords++;
  144. }
  145.  
  146. #if    RAMSIZE & LATTICE & MSDOS
  147. /*    These routines will allow me to track memory usage by placing
  148.     a layer on top of the standard system malloc() and free() calls.
  149.     with this code defined, the number of allocated bytes is displayed
  150.     in the upper right corner of the screen
  151. */
  152.  
  153. #undef    malloc
  154. #undef    free
  155.  
  156. char *allocate(nbytes)    /* allocate nbytes and track */
  157.  
  158. unsigned nbytes;    /* # of bytes to allocate */
  159.  
  160. {
  161.     char *mp;    /* ptr returned from malloc */
  162.     char *malloc();
  163.  
  164.     mp = malloc(nbytes);
  165.     if (mp) {
  166.         envram += nbytes;
  167. #if    RAMSHOW
  168.         dspram();
  169. #endif
  170.     }
  171.  
  172.     return(mp);
  173. }
  174.  
  175. release(mp)    /* release malloced memory and track */
  176.  
  177. char *mp;    /* chunk of RAM to release */
  178.  
  179. {
  180.     unsigned *lp;    /* ptr to the long containing the block size */
  181.  
  182.     if (mp) {
  183.         lp = ((unsigned *)mp) - 1;
  184.  
  185.         /* update amount of ram currently malloced */
  186.         envram -= (long)*lp - 2;
  187.         free(mp);
  188. #if    RAMSHOW
  189.         dspram();
  190. #endif
  191.     }
  192. }
  193.  
  194. #if    RAMSHOW
  195. dspram()    /* display the amount of RAM currently malloced */
  196.  
  197. {
  198.     char mbuf[20];
  199.     char *sp;
  200.  
  201. /*    TTmove(term.t_nrow - 1, 70);*/
  202.     sprintf(mbuf, "[%lu]", envram);
  203.     sp = &mbuf[0];
  204.     puts(sp);
  205. }
  206. #endif
  207. #endif
  208.  
  209. #if    AZTEC & MSDOS
  210. #undef    fgetc
  211. #undef    fgets
  212. /*    a1gets:        Get an ascii string from a file using a1getc    */
  213.  
  214. char *a1gets(buffer, length, fp)
  215.  
  216. char *buffer;    /* buffer to leave string in */
  217. int length;    /* maximum length of string */
  218. FILE *fp;    /* file to get string from */
  219.  
  220. {
  221.     register int c;        /* current character read */
  222.     register char *bp;    /* pointer into buffer */
  223.  
  224.     bp = buffer;
  225.  
  226.     while ((c = a1getc(fp))    != EOF) {
  227.         *bp++ = (char)c;
  228.         if (c == '\n')
  229.             break;
  230.     }
  231.  
  232.     *bp = 0;
  233.     if (c == EOF)
  234.         return(NULL);
  235.     else
  236.         return(buffer);
  237. }
  238.  
  239. /*    a1getc:        Get an ascii char from the file input stream
  240.             but DO NOT strip the high bit
  241. */
  242.  
  243. int a1getc(fp)
  244.  
  245. FILE *fp;
  246.  
  247. {
  248.     int c;        /* translated character */
  249.  
  250.     c = getc(fp);    /* get the character */
  251.  
  252.     /* if its a <LF> char, throw it out  */
  253.     while (c == 10)
  254.         c = getc(fp);
  255.  
  256.     /* if its a <RETURN> char, change it to a LF */
  257.     if (c == '\r')
  258.         c = '\n';
  259.  
  260.     /* if its a ^Z, its an EOF */
  261.     if (c == 26)
  262.         c = EOF;
  263.  
  264.     return(c);
  265. }
  266. #endif
  267.  
  268. perform(cmd)    /* send out a DOS command and execute it */
  269.  
  270. char *cmd;    /* command to execute */
  271.  
  272. {
  273.     if (swdebug)    /* output command string with diagnostics */
  274.         puts(cmd);
  275.  
  276. #if    LATTICE & ~CMS
  277.     forkl(getenv("COMSPEC"),"command","-C",cmd,NULL);
  278.     return(wait());
  279. #endif
  280.  
  281. #if    AZTEC | CMS
  282.     system(cmd);
  283.     return(TRUE);
  284. #endif
  285. }
  286.  
  287. #if    CMS
  288. #undef    fopen
  289. /*    The IBM 30xx likes to tell us when file opens
  290.     fail...it's too chatty....I like to handle these myself    */
  291.  
  292. FILE *cmsopen(file, mode)
  293.  
  294. char *file;    /* name of file to open */
  295. char *mode;    /* mode to open it in */
  296.  
  297. {
  298.     quiet(1);
  299.     return(fopen(file,mode));
  300. }
  301. #endif
  302.  
  303.